﻿using System;
using System.Windows;
using ibba.src.sl.recursos.MVVM;

namespace ibba.src.noriskbo.ViewModels
{
    public class AppStartupViewModel : ViewModelBase
    {
        public delegate void FimProcessamento();
        public event FimProcessamento OnFimProcessamento;

        private System.Windows.Threading.DispatcherTimer _dispatcherTimer;
        
        public enum eTipoMensagemRodape
        {
            Aguarde = 0,
            Erro = 1
        }
                

        public AppStartupViewModel()
        {
            base.TitleView = "Back Office";

            _dispatcherTimer = new System.Windows.Threading.DispatcherTimer();
            _dispatcherTimer.Interval = TimeSpan.FromSeconds(30);
            _dispatcherTimer.Tick +=new EventHandler(_dispatcherTimer_Tick);

            this.IsWaitPerfil = false;
            this.MensagemPerfil = "Verificando Perfil de Acesso";

            this.IsWaitProcessamentoRisco = false;
            this.MensagemProcessamentoRisco = "Verificando Processamento do Risco";
            
            if (!base.IsInDesignMode)
            {
                this.PainelPerfilVisivel = Visibility.Collapsed;
                this.PainelProcessamentoVisivel = Visibility.Collapsed;
                this.MensagemRodapeVisivel = Visibility.Collapsed;

                _diretorioVirtual = AmbienteHelper.Instance.DiretorioVirtual;
                this.ServidorWeb = AppHelper.Servidor;
                this.ServidorMTSLB = AmbienteHelper.Instance.ServidorComponentes;
                this.ServidorMTSFixo = AmbienteHelper.Instance.ServidorComponentesFixo;

                ObterPerfil();
            }
        }


        #region [ Model ]

        private string _diretorioVirtual;
        public string DiretorioVirtual
        {
            get { return _diretorioVirtual; }
            private set { base.SetValue("DiretorioVirtual", ref _diretorioVirtual, value); }
        }

        private string _servidorWeb;
        public string ServidorWeb
        {
            get { return _servidorWeb; }
            private set { base.SetValue("ServidorWeb", ref _servidorWeb, value); }
        }

        private string _servidorMTSLB;
        public string ServidorMTSLB
        {
            get { return _servidorMTSLB; }
            private set { base.SetValue("ServidorMTSLB", ref _servidorMTSLB, value); }
        }

        private string _servidorMTSFixo;
        public string ServidorMTSFixo
        {
            get { return _servidorMTSFixo; }
            private set { base.SetValue("ServidorMTSFixo", ref _servidorMTSFixo, value); }
        }

        private string _messagemPerfil;
        public string MensagemPerfil
        {
            get { return _messagemPerfil; }
            private set { base.SetValue("MensagemPerfil", ref _messagemPerfil, value); }
        }

        private string _retornoPerfil;
        public string RetornoPerfil
        {
            get { return _retornoPerfil; }
            private set { base.SetValue("RetornoPerfil", ref _retornoPerfil, value); }
        }

        private bool _isWaitPerfil;
        public bool IsWaitPerfil
        {
            get { return _isWaitPerfil; }
            private set { base.SetValue("IsWaitPerfil", ref _isWaitPerfil, value); }
        }
        
        private Visibility _painelPerfilVisivel;
        public Visibility PainelPerfilVisivel
        {
            get { return _painelPerfilVisivel; }
            private set { base.SetValue("PainelPerfilVisivel", ref _painelPerfilVisivel, value); }
        }

        private string _messagemProcessamentoRisco;
        public string MensagemProcessamentoRisco
        {
            get { return _messagemProcessamentoRisco; }
            private set { base.SetValue("MensagemProcessamentoRisco", ref _messagemProcessamentoRisco, value); }
        }

        private string _retornoProcessamentoRisco;
        public string RetornoProcessamentoRisco
        {
            get { return _retornoProcessamentoRisco; }
            private set { base.SetValue("RetornoProcessamentoRisco", ref _retornoProcessamentoRisco, value); }
        }

        private bool _isWaitProcessamentoRisco;
        public bool IsWaitProcessamentoRisco 
        {
            get { return _isWaitProcessamentoRisco; }
            private set { base.SetValue("IsWaitProcessamentoRisco", ref _isWaitProcessamentoRisco, value); }
        }

        private Visibility _painelProcessamentoVisivel;
        public Visibility PainelProcessamentoVisivel
        {
            get { return _painelProcessamentoVisivel; }
            private set { base.SetValue("PainelProcessamentoVisivel", ref _painelProcessamentoVisivel, value); }
        }

        private string _mensagemRodape;
        public string MensagemRodape
        {
            get { return _mensagemRodape; }
            private set
            { 
                base.SetValue("MensagemRodape", ref _mensagemRodape, value);
                this.MensagemRodapeVisivel = _mensagemRodape.Length > 0 ? Visibility.Visible : Visibility.Collapsed;
            }
        }

        private Visibility _mensagemRodapeVisivel;
        public Visibility MensagemRodapeVisivel
        {
            get { return _mensagemRodapeVisivel; }
            private set { base.SetValue("MensagemRodapeVisivel", ref _mensagemRodapeVisivel, value); }
        }

        private eTipoMensagemRodape _tipoMensagemRodape;
        public eTipoMensagemRodape TipoMensagemRodape
        {
            get { return _tipoMensagemRodape; }
            private set { base.SetValue("TipoMensagemRodape", ref _tipoMensagemRodape, value); }
        }

        private bool _acessoLiberado;
        public bool AcessoLiberado
        {
            get { return AppHelper.Perfil.Count > 0 && _acessoLiberado; }
        }

        #endregion


        void _dispatcherTimer_Tick(object sender, EventArgs e)
        {
            this.VerificarProcessamentoRisco();            
        }

        private void ObterPerfil()
        {
            this.MensagemPerfil = "Verificando Perfil de Acesso";

            this.IsWaitPerfil = true;
            this.PainelPerfilVisivel = Visibility.Visible;

            ServiceFactory.Instance.ServiceAcesso.BeginObterPerfil(AppHelper.LoginUsuario, AppHelper.IdSistema,
                                                                      CallBackObterPerfil, ServiceFactory.Instance.ServiceAcesso);
        }
        private void CallBackObterPerfil(IAsyncResult pAsyncResult)
        {
            System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                this.IsWaitPerfil = false;
                
                try
                {                    
                    var retorno = ((ServiceAcesso.IAcesso)pAsyncResult.AsyncState).EndObterPerfil(pAsyncResult);

                    AppHelper.Perfil = retorno;

                    this.MensagemPerfil = "Perfil de acesso verificado com sucesso!";

                    this.RetornoPerfil = "";
                    foreach (var item in retorno)
                    {
                        this.RetornoPerfil += item + "\n";
                    }

                    if (retorno.Count > 0)
                        VerificarProcessamentoRisco();
                    else
                    {
                        this.TipoMensagemRodape = eTipoMensagemRodape.Aguarde;
                        this.MensagemRodape = string.Concat("AVISO:\n\nAcesso não permitido para o usuário\n", AppHelper.NomeUsuario);
                    }
                }
                catch (Exception ex)
                {
                    AppHelper.Perfil = null;
                    this.MensagemPerfil = "Perfil de acesso verificado com ERRO...";
                    this.RetornoPerfil = "";
                    this.TipoMensagemRodape = eTipoMensagemRodape.Erro;
                    this.MensagemRodape = "Erro:\nNão foi possível verificar o perfil de acesso.";

                    MessageBoxHelper.ShowErro(AppHelper.NomeSistema
                            , "Ocorreu um erro ao verificar o seu perfil de acesso."
                            , String.Format("{1}{0}{0}::StackTrace{0}{2}", "\n", ex.Message, ex.StackTrace));

                }

            });

        }

        private void VerificarProcessamentoRisco()
        {
            _dispatcherTimer.Stop();

            this.IsWaitProcessamentoRisco = true;
            this.PainelProcessamentoVisivel = Visibility.Visible;
            this.MensagemProcessamentoRisco = "Verificando Processamento do Risco";

            ServiceFactory.Instance.ServiceProcessamento.BeginObterProcessamento(DateTime.Now, VerificarProcessamentoRiscoCallBack,
                                                                                    ServiceFactory.Instance.ServiceProcessamento);
        }

        private void VerificarProcessamentoRiscoCallBack(IAsyncResult pAsyncResult)
        {
            System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                _acessoLiberado = false;

                try
                {
                    ServiceProcessamento.Processamento processamento = ((ServiceProcessamento.IServiceProcessamento)pAsyncResult.AsyncState).EndObterProcessamento(pAsyncResult);
                    if (processamento == null || processamento.Terminio.HasValue == false)
                    {
                        string msg;

                        this.TipoMensagemRodape = eTipoMensagemRodape.Aguarde;

                        if (processamento == null)
                        {
                            msg = string.Format("{1}{0}{0}{2}{0}{3}"
                                             , "\n"
                                             , "O sistema de Risco de Crédito ainda não foi processado."
                                             , "Assim que o processamento for concluído esta mensagem será"
                                             , "fechada automaticamente e o sistema estará liberado para uso.");
                        }
                        else
                        {
                            msg = string.Format("{1}{0}{0}{2}{0}{3}{4}"
                                             , "\n"
                                             , "O sistema de Risco de Crédito está em processamento."
                                             , "Favor aguardar!"
                                             , "Data de referência: "
                                             , processamento.DataReferencia.ToShortDateString());
                        }



                        this.MensagemRodape = string.Format("{0}{1}{0}{2}{3}"
                                                            , "\n"
                                                            , msg                                                      
                                                            , "Atualizado em: "
                                                            , DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss"));

    
                        _dispatcherTimer.Start();
                    }
                    else
                    {
                        if (processamento.Terminio.HasValue)
                        {
                            _acessoLiberado = true;
                            this.IsWaitProcessamentoRisco = false;

                            if (OnFimProcessamento != null & AppHelper.Perfil.Count > 0)
                                OnFimProcessamento();
                        }
                    }
                    
                }
                catch (Exception ex)
                {
                    _dispatcherTimer.Stop();

                    this.IsWaitProcessamentoRisco = false;
                    this.MensagemProcessamentoRisco= "Processamento do Risco verificado com ERRO...";
                    this.TipoMensagemRodape = eTipoMensagemRodape.Erro;
                    this.MensagemRodape = "Erro:\nNão foi possível verificar se processamento do risco foi finalizado.";

                    MessageBoxHelper.ShowErro(AppHelper.NomeSistema
                            , "Ocorreu um erro ao verificar o seu processamento do risco."
                            , String.Format("{1}{0}{0}::StackTrace{0}{2}", "\n", ex.Message, ex.StackTrace));
                }
                finally 
                {
                    base.RaisePropertyChanged("AcessoLiberado");
                }
            });
        }
    }
}
